package com.cssy.yd.logic.service.impl;

import java.util.Date;
import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSONArray;
import com.byd.acegiext.domain.User;
import com.cssy.yd.logic.dao.LogicSoDAO;
import com.cssy.yd.logic.dao.LogicSoItemDAO;
import com.cssy.yd.logic.dao.LogicSoReturnDAO;
import com.cssy.yd.logic.dao.LogicSoReturnItemBatchDAO;
import com.cssy.yd.logic.dao.LogicSoReturnItemDAO;
import com.cssy.yd.logic.dao.LogicSoWareDAO;
import com.cssy.yd.logic.dao.LogicSoWareItemBatchDAO;
import com.cssy.yd.logic.dao.LogicSoWareItemDAO;
import com.cssy.yd.logic.dao.LogicSoWareItemFreezedealbatchDAO;
import com.cssy.yd.logic.entity.LogicSoDO;
import com.cssy.yd.logic.entity.LogicSoItemDO;
import com.cssy.yd.logic.entity.LogicSoReturnDO;
import com.cssy.yd.logic.entity.LogicSoReturnItemBatchDO;
import com.cssy.yd.logic.entity.LogicSoReturnItemDO;
import com.cssy.yd.logic.entity.LogicSoWareDO;
import com.cssy.yd.logic.entity.LogicSoWareItemBatchDO;
import com.cssy.yd.logic.entity.LogicSoWareItemDO;
import com.cssy.yd.logic.entity.LogicSoWareItemFreezedealbatchDO;
import com.cssy.yd.logic.entity.LogicWhAffDO;
import com.cssy.yd.logic.service.ILogicSoReturnService;
import com.cssy.yd.logic.service.ILogicWhAffStockService;
import com.plat.exception.SyBaseException;
import com.plat.helper.SearchCondition;
import com.plat.helper.SearchConditions;
import com.plat.helper.SearchResult;
import com.plat.util.DateUtils;
import com.plat.util.GlobalResLoader;
import com.plat.util.IDCodeTypeUtil;
import com.plat.util.SessionUtil;
import com.yuendong.sy.po.code.SyCode;
import com.yuendong.sy.service.code.SyCodeType;
import com.yuendong.sy.service.code.impl.SyCodeService;

@Service("logicSoReturnService")
public class LogicSoReturnServiceImpl implements ILogicSoReturnService{
	private final static Logger logger = Logger.getLogger(LogicSoReturnServiceImpl.class);
	
	@Resource(name = "logicSoReturnDAO")
	private LogicSoReturnDAO logicSoReturnDAO;
	
	@Resource(name = "logicSoWareItemDAO")
	private LogicSoWareItemDAO logicSoWareItemDAO;
	
	@Resource(name = "logicSoWareDAO")
	private LogicSoWareDAO logicSoWareDAO;
	
	@Resource(name = "logicSoReturnItemDAO")
	private LogicSoReturnItemDAO logicSoReturnItemDAO;
	
	@Resource(name = "logicSoDAO")
	private LogicSoDAO logicSoDAO;
	
	@Resource(name = "logicSoItemDAO")
	private LogicSoItemDAO logicSoItemDAO;
	
	@Resource(name = "syCodeService")
	private SyCodeService syCodeService;
	
	@Resource(name = "logicWhAffStockService")
	private ILogicWhAffStockService logicWhAffStockService;
	
	@Resource(name="logicSoWareItemBatchDAO")
	private LogicSoWareItemBatchDAO logicSoWareItemBatchDAO;

	
	@Resource(name="logicSoWareItemFreezedealbatchDAO")
	private LogicSoWareItemFreezedealbatchDAO logicSoWareItemFreezedealbatchDAO;
	
	@Resource(name="logicSoReturnItemBatchDAO")
	private LogicSoReturnItemBatchDAO logicSoReturnItemBatchDAO;
	
	@Override
	public SearchResult findListByExample(SearchConditions scs)
			throws SyBaseException {
		SearchResult rs=new SearchResult(scs);
		List<LogicSoReturnDO>  list=logicSoReturnDAO.find(scs);
		rs.setRecordCount(logicSoReturnDAO.count(scs));
		rs.setResults(list);
		return rs;
	}

	@Override
	public Integer delete(String id, User user) throws SyBaseException {
		Integer i =logicSoReturnDAO.deleteLogicSoReturnDOByPrimaryKey(id);
		return i;
	}

	@Override
	public Integer update(LogicSoReturnDO t, User user) throws SyBaseException {
		t.setDuuser(user.getName());
		t.setDutime(new Date());
		return logicSoReturnDAO.updateLogicSoReturnDO(t);
	}

	@Override
	public LogicSoReturnDO save(LogicSoReturnDO t, User user) throws SyBaseException {
		t.setDcruser(user.getName());
		t.setDctime(new Date());
		t.setId(IDCodeTypeUtil.getId());
		logicSoReturnDAO.insertLogicSoReturnDO(t);
		return t;
	}

	@Override
	public LogicSoReturnDO findListById(String id) throws SyBaseException {
		return logicSoReturnDAO.findLogicSoReturnDOByPrimaryKey(id);
	}
	
	@Override
	public SearchResult findItemListByExample(SearchConditions scs)
			throws SyBaseException {
		SearchResult rs=new SearchResult(scs);
		List<LogicSoReturnItemDO>  list=logicSoReturnItemDAO.find(scs);
		rs.setRecordCount(logicSoReturnItemDAO.count(scs));
		rs.setResults(list);
		return rs;
	}

	@Override
	public Integer deleteItem(String id) throws SyBaseException {
		Integer i =logicSoReturnItemDAO.deleteLogicSoReturnItemDOByPrimaryKey(id);
		return i;
	}

	@Override
	public Integer updateItem(LogicSoReturnItemDO t) throws SyBaseException {
		return logicSoReturnItemDAO.updateLogicSoReturnItemDO(t);
	}

	@Override
	public LogicSoReturnItemDO saveItem(LogicSoReturnItemDO t) throws SyBaseException {
		t.setId(IDCodeTypeUtil.getId());
		logicSoReturnItemDAO.insertLogicSoReturnItemDO(t);
		return t;
	}

	@Override
	public LogicSoReturnItemDO findItemListById(String id) throws SyBaseException {
		return logicSoReturnItemDAO.findLogicSoReturnItemDOByPrimaryKey(id);
	}

	@Override
	public List<LogicSoReturnItemDO> findItemListBypoId(String id)
			throws SyBaseException {
		return null;
	}

	

	@Override
	public void returnsave(HttpServletRequest request, LogicSoReturnDO curAP)
			throws SyBaseException {
		try {
			String itemdata = request.getParameter("itemdata");
			List<LogicSoReturnItemDO> axxlist=JSONArray.parseArray(itemdata, LogicSoReturnItemDO.class);
			
			String paramflag = request.getParameter("submitFlag");
			int iToFlag = -1;
			iToFlag = Integer.parseInt(paramflag);
			curAP.setBillstatus(Integer.parseInt(paramflag));
			
			User user = SessionUtil.getUser(request);
			Date curDate = new Date();
			
			if (StringUtils.isBlank(curAP.getId())) {
				/* 新增  设置状态billstatus= 1*/
				
				//---start 判断单据是否存在未完成处理的记录
				if(StringUtils.isBlank(curAP.getOricode())){
					throw new SyBaseException("销售申请单编号参数为空");
				}
				SearchConditions soScs = new SearchConditions();
				soScs.addCondition("oricode", curAP.getOricode(), SearchCondition.OP_EQUAL);
				soScs.addCondition("billstatus", "3", SearchCondition.OP_NOTEQUAL);
				soScs.addCondition("billstatus", "4", SearchCondition.OP_NOTEQUAL);
				Integer count = logicSoReturnDAO.count(soScs);
				if(null != count && count > 0){
					throw new SyBaseException(curAP.getSoNo()+"销售申请单存在未处理的销售冻结处理单");
				}
				//---end 判断单据是否存在未完成处理的记录
				
				String id=IDCodeTypeUtil.getId();
				curAP.setReturnsocode(syCodeService.getCode("XT","XT",SyCode.DATE_YYMM,5));
				curAP.setId(id);
				
				curAP.setDcruser(user.getName());
				curAP.setDctime(curDate);
				
				//日期转换处理
				String returnDate = request.getParameter("returnDate");
				if(StringUtils.isNotBlank(returnDate)){
					curAP.setReturnDate( DateUtils.stringToDate(returnDate));
				}
				String deliveryDate = request.getParameter("deliveryDate");
				if(StringUtils.isNotBlank(deliveryDate)){
					curAP.setDeliveryDate(DateUtils.stringToDate(deliveryDate));
				}
				
				curAP.setRefundStatus(0);//退款状态-未退款
				logicSoReturnDAO.insertLogicSoReturnDO(curAP);
				
				curAP.setId(id);//添加上，否则插入之后ID为0
				//更新或添加item
				saveOrUpdateItems(axxlist, curAP);
				
			} else if(iToFlag >= 2 && iToFlag <=5){
				/* 修改 */
				LogicSoReturnDO bean = logicSoReturnDAO.findLogicSoReturnDOByPrimaryKey(curAP.getId());
				if(null == bean.getVersion() || !bean.getVersion().equals(curAP.getVersion())){
					throw new SyBaseException("版本号异常，请刷新后重新编辑");
				}
				
				bean.setBillstatus(iToFlag);//单据状态
				
				int result = 0;
				if(2==iToFlag ){//2为二级审核(提交二级审核)审批中
					curAP.setVersion(bean.getVersion());
					curAP.setBillstatus(bean.getBillstatus());
					
					curAP.setLister(user.getName());
					curAP.setListerName(user.getRealName());
					curAP.setDutime(curDate);
					curAP.setDuuser(user.getName());
					
					//日期转换处理
					String returnDate = request.getParameter("returnDate");
					if(StringUtils.isNotBlank(returnDate)){
						curAP.setReturnDate( DateUtils.stringToDate(returnDate));
					}
					String deliveryDate = request.getParameter("deliveryDate");
					if(StringUtils.isNotBlank(deliveryDate)){
						curAP.setDeliveryDate(DateUtils.stringToDate(deliveryDate));
					}
					
					result =logicSoReturnDAO.updateLogicSoReturnDO(curAP);
					if(result==1){
						//更新或添加item
						saveOrUpdateItems(axxlist, curAP);
					}
					
				}else if(3==iToFlag ){//已完成
					
					bean.setAuditor(user.getName());//二级
					bean.setAuditorName(user.getRealName());
					bean.setDutime(curDate);
					bean.setDuuser(user.getName());
					//退货单持久化
					result =logicSoReturnDAO.updateLogicSoReturnDO(curAP);
					
					/* 退货处理 */
					/*
					 * 根据出库单进行退货
					 * @author huang.xuming[2013-09-25]
					 */
					
					//根据出库单编码获取出库单信息
					SearchConditions scs = new SearchConditions();
					scs.addCondition("no",curAP.getOricode(),SearchCondition.OP_EQUAL);
					List<LogicSoWareDO> lpwlist=logicSoWareDAO.find(scs);
					if(null ==lpwlist || 0==lpwlist.size()){
						throw new SyBaseException(curAP.getOricode()+"出库单编码的单据为空");
					}
					LogicSoWareDO lpw = lpwlist.get(0);
					List<LogicSoWareItemDO> lpwitem = null;
					lpwitem = logicSoWareItemDAO.findItemListBysowareId(lpw.getId());
					if(null ==lpwitem){
						throw new SyBaseException(curAP.getOricode()+"出库单编码的item列表为空");
					}
					
					//根据销售订单编号，获取销售订单信息 -- 20130905
					SearchConditions scs2 = new SearchConditions();
					scs2.addCondition("no",curAP.getSoNo(),SearchCondition.OP_EQUAL);
					List<LogicSoDO> solist=logicSoDAO.find(scs2);
					if(null ==solist || 0==solist.size()){
						throw new SyBaseException(curAP.getSoNo()+"销售单编码的单据为空");
					}
					LogicSoDO so = solist.get(0);
					List<LogicSoItemDO> soitem = null;
					soitem = logicSoItemDAO.findItemListBysoId(so.getId());
					if(null ==soitem){
						throw new SyBaseException(curAP.getSoNo()+"销售单编码的item列表为空");
					}
					
					//全部退货标记
					boolean isSwFullReturn=true;
					
					for(LogicSoReturnItemDO item2:axxlist){
						Double sqthQuantity = item2.getSqthQuantity();
						Double sqthBQuantity = item2.getSqthBQuantity();
						if(sqthQuantity <=0 || sqthBQuantity <= 0){
							throw new SyBaseException(curAP.getReturnsocode()+"销售退款单编码的，"+item2.getProdNo()+"产品退货申请数量不合法");
						}
						
						/* 出库单item处理 */
//						Double sqthQty1 = sqthQuantity;
						for(LogicSoWareItemDO item1:lpwitem){
							//产品匹配   存在冻结出库时，可以执行多次。
							if(item1.getProdNo().equals(item2.getProdNo())
									&& item1.getSourceBillType().equals(item2.getSourceBillType())
									&& item1.getStatus().equals(item2.getStatus())
									){
								//出库单item的可退数量 = 出库单出库数量-已退货数量
//								Double canThQty = item1.getProdSfquantity() - item1.getYtQuantity();
								
//								if(canThQty > 0){
//									Double curThQty = sqthQty1;
//									if(canThQty < sqthQty1){
//										curThQty = canThQty;
//										//throw new SyBaseException(curAP.getOricode()+"出库单编码的产品编码（"+item1.getProdNo()+"）申请退货数量大于可退货数量");
//									}
//									
//									sqthQty1 -=curThQty;
//									
//									//出库单相应item持久化
//									item1.setYtQuantity(item1.getYtQuantity()+curThQty);
//									item1.setYtBQuantity(item1.getYtBQuantity()+MathUtil.mathUtil.multiply(curThQty, item1.getProdUnitConvert()));
//									logicSoWareItemDAO.updateLogicSoWareItemDO(item1);//已退数量的持久化
//									
//								}
								if(item2.getItemBatch()!=null && !"".equals(item2.getItemBatch())){
									List<LogicSoReturnItemBatchDO> retrunItem=JSONArray.parseArray(item2.getItemBatch(), LogicSoReturnItemBatchDO.class);
									if(1==item1.getSourceBillType()){
										List<LogicSoWareItemBatchDO>logicSoWareItemBatchDO= logicSoWareItemBatchDAO.findBywareItemid(item1.getId());
										for (LogicSoWareItemBatchDO logicSoWareItemBatchDO2 : logicSoWareItemBatchDO) {
											for (LogicSoReturnItemBatchDO item : retrunItem) {
												if(item.getProdNo().equals(logicSoWareItemBatchDO2.getProdNo())
														&& item.getProdBatch().equals(logicSoWareItemBatchDO2.getProdBatch())
														&& item.getStatus().equals(logicSoWareItemBatchDO2.getStatus())){
													logicSoWareItemBatchDO2.setYtQuantity((logicSoWareItemBatchDO2.getYtQuantity()==null?0:logicSoWareItemBatchDO2.getYtQuantity())+item.getSqthBQuantity());
													logicSoWareItemBatchDO2.setYtBQuantity((logicSoWareItemBatchDO2.getYtBQuantity()==null?0:logicSoWareItemBatchDO2.getYtBQuantity())+item.getSqthBQuantity());
												}
												logicSoWareItemBatchDAO.updateLogicSoWareItemBatchDO(logicSoWareItemBatchDO2);
											}
											
										}
										item1.setYtQuantity((item1.getYtQuantity()==null?0:item1.getYtQuantity())+sqthQuantity);
										item1.setYtBQuantity((item1.getYtBQuantity()==null?0:item1.getYtBQuantity())+sqthBQuantity);
										item1.setItemBatch(JSONArray.toJSONString(logicSoWareItemBatchDO));
										logicSoWareItemDAO.updateLogicSoWareItemDO(item1);//已退数量的持久化
									}else if(2==item1.getSourceBillType()){
										List<LogicSoWareItemFreezedealbatchDO>	lWareItemFreezedealbatchDOs= logicSoWareItemFreezedealbatchDAO.findbyfreezedealItemid(item1.getId());
										for (LogicSoWareItemFreezedealbatchDO fBatchDO : lWareItemFreezedealbatchDOs) {
											for (LogicSoReturnItemBatchDO item : retrunItem) {
												if(item.getProdNo().equals(fBatchDO.getProdNo())
														&& item.getProdBatch().equals(fBatchDO.getProdBatch())
														&& item.getStatus().equals(fBatchDO.getStatus())){
													fBatchDO.setYtQuantity((fBatchDO.getYtQuantity()==null?0:fBatchDO.getYtQuantity())+item.getSqthBQuantity());
													fBatchDO.setYtBQuantity((fBatchDO.getYtBQuantity()==null?0:fBatchDO.getYtBQuantity())+item.getSqthBQuantity());
												}
												logicSoWareItemFreezedealbatchDAO.updateLogicSoWareItemFreezedealbatchDO(fBatchDO);
											}
											
										}
										item1.setYtQuantity((item1.getYtQuantity()==null?0:item1.getYtQuantity())+sqthQuantity);
										item1.setYtBQuantity((item1.getYtBQuantity()==null?0:item1.getYtBQuantity())+sqthBQuantity);
										item1.setItemBatch(JSONArray.toJSONString(lWareItemFreezedealbatchDOs));
										logicSoWareItemDAO.updateLogicSoWareItemDO(item1);//已退数量的持久化
									}
								}else{
									item1.setYtQuantity((item1.getYtQuantity()==null?0:item1.getYtQuantity())+sqthQuantity);
									item1.setYtBQuantity((item1.getYtBQuantity()==null?0:item1.getYtBQuantity())+sqthBQuantity);
									logicSoWareItemDAO.updateLogicSoWareItemDO(item1);//已退数量的持久化
								}
								
							}
						}
//						//检查是否存在未完成退库的数量
//						if(sqthQty1 > 0){
//							throw new SyBaseException(curAP.getReturnsocode()+"销售退款单编码的，"+item2.getProdNo()+"产品退货时，未能从相应出库单中完成退货");
//						}
						
						
						/* 订单item处理 */
//						Double sqthQty2 = sqthQuantity;
						for(LogicSoItemDO curSoItem : soitem){
							//产品匹配  理论上不可以执行多次，但预留。
							if(curSoItem.getProdNo().equals(item2.getProdNo())
									&& curSoItem.getStatus().equals(item2.getStatus())
									){
								//订单item的可退数量 = 出库数量-已退货数量
//								Double canThQty = curSoItem.getCkQuantity() - curSoItem.getYtQuantity();
//								if(canThQty > 0){
//									Double curThQty = sqthQty2;
//									if(canThQty < sqthQty2){
//										curThQty = canThQty;
//										//throw new SyBaseException(curAP.getOricode()+"出库单编码的产品编码（"+item1.getProdNo()+"）申请退货数量大于可退货数量");
//									}
//									
//									sqthQty2 -=curThQty;
//									
//									//销售订单相应item持久化
//									curSoItem.setYtQuantity(curSoItem.getYtQuantity()+curThQty);
//									curSoItem.setYtBQuantity(curSoItem.getYtBQuantity()+MathUtil.mathUtil.multiply(curThQty, curSoItem.getProdUnitConvert()));
//									logicSoItemDAO.updateLogicSoItemDO(curSoItem);
//								}
								curSoItem.setYtQuantity((curSoItem.getYtQuantity()==null?0:curSoItem.getYtQuantity())+sqthQuantity);
								curSoItem.setYtBQuantity((curSoItem.getYtBQuantity()==null?0:curSoItem.getYtBQuantity())+sqthBQuantity);
								logicSoItemDAO.updateLogicSoItemDO(curSoItem);
							}
						}
//						//检查是否存在未完成退库的数量
//						if(sqthQty2 > 0){
//							throw new SyBaseException(curAP.getReturnsocode()+"销售退款单编码的，"+item2.getProdNo()+"产品退货时，未能从相应销售订单中完成退货");
//						}
						
						/* 仓库处理，退货入库 */
						dealWhaff(curAP, item2, user);
					}
					
					//出库单部分退货、完全退货标识处理
					for(LogicSoWareItemDO item1:lpwitem){
						if(item1.getProdSfquantity() > item1.getYtQuantity()){
							isSwFullReturn=false;
						}else if(item1.getProdSfquantity() < item1.getYtQuantity()){
							throw new SyBaseException(curAP.getOricode()+"销售出库单编码的产品编码（"+item1.getProdNo()+"）退货数量大于出库数量");
						}
					}
					
					
					//出库单的出库状态修改
					lpw.setWareStatus((true==isSwFullReturn)?4/*全部退货*/:3/*部分退货*/);
					logicSoWareDAO.updateLogicSoWareDO(lpw);
					
					//销售订单单完全退货标识处理
					// XXX 后续修改
					
					
				}else if(4==iToFlag ){//设置关闭
					bean.setLister(user.getName());
					bean.setListerName(user.getRealName());
					bean.setDutime(curDate);
					bean.setDuuser(user.getName());
					result =logicSoReturnDAO.updateLogicSoReturnDO(bean);
				}else if(5==iToFlag ){//设置已驳回
					bean.setAuditor(user.getName());//二级
					bean.setAuditorName(user.getRealName());
					bean.setDutime(curDate);
					bean.setDuuser(user.getName());
					result =logicSoReturnDAO.updateLogicSoReturnDO(curAP);
				}else{
					throw new SyBaseException("ParamFlag不合法："+paramflag);
				}
				
			}else{
				throw new SyBaseException("ParamFlag不合法："+paramflag);
			}
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
			throw new SyBaseException(GlobalResLoader.getOpfailed()+ e.getMessage());
		}
	}

	/**
	 * 单据的子项持久化
	 * @param soItemlist
	 * @param curAP
	 */
	private void saveOrUpdateItems(List<LogicSoReturnItemDO> axxlist ,LogicSoReturnDO curAP){
		//删除本订单下的item
		if(null != curAP.getId()){
				SearchConditions scs = new SearchConditions();
				scs.addCondition("returnsoid", curAP.getId(), SearchCondition.OP_EQUAL);
				scs.setRemovedProperty(null);
				scs.setLimitPage(false);
				List<LogicSoReturnItemDO> logicSoReturnItemDOs = logicSoReturnItemDAO.find(scs);
				if(logicSoReturnItemDOs != null){
					for (int i = 0; i < logicSoReturnItemDOs.size(); i++) {
						logicSoReturnItemBatchDAO.deleteByreturnitemid(logicSoReturnItemDOs.get(i).getId());
						
					}
					logicSoReturnItemDAO.deleteLogicSoReturnItemDOBy(curAP.getId());
				}
		}
		//插入单据的item
		if(null != axxlist){
			for (LogicSoReturnItemDO soItemDO : axxlist) {
				String returnid =IDCodeTypeUtil.getId();
				soItemDO.setReturnsoid(curAP.getId());
				soItemDO.setId(returnid);
				soItemDO.setReturnsocode(curAP.getReturnsocode());
				
				logicSoReturnItemDAO.insertLogicSoReturnItemDO(soItemDO);
				if(soItemDO.getItemBatch() != null && !"".equals(soItemDO.getItemBatch().trim())){
					List<LogicSoReturnItemBatchDO> itemBatchDOs = JSONArray.parseArray(soItemDO.getItemBatch(),LogicSoReturnItemBatchDO.class);
					for (int i = 0; i < itemBatchDOs.size(); i++) {
						itemBatchDOs.get(i).setId(IDCodeTypeUtil.getId());
						itemBatchDOs.get(i).setReturnitemid(returnid);
						logicSoReturnItemBatchDAO.insertLogicSoReturnItemBatchDO(itemBatchDOs.get(i));
					}
			}
			}
		}
		
	}
	
	/**
	 * 仓库处理
	 * @param curAP
	 * @param item2
	 */
	private void dealWhaff(LogicSoReturnDO curAP, LogicSoReturnItemDO item2,User user){
		if("Y".equals(item2.getOpenBatch())){
			if(item2.getItemBatch()!=null && !"".equals(item2.getItemBatch())){
				List<LogicSoReturnItemBatchDO> itemBatchDOs=JSONArray.parseArray(item2.getItemBatch(), LogicSoReturnItemBatchDO.class);
				for (LogicSoReturnItemBatchDO returnItemBatchDO : itemBatchDOs) {
					LogicWhAffDO lwhaff=new LogicWhAffDO();
					lwhaff.setCode(item2.getProdNo());
					lwhaff.setName(item2.getProdName());
					lwhaff.setSpec(item2.getProdSpecDesc());
					lwhaff.setBatch(returnItemBatchDO.getProdBatch());
					lwhaff.setBrand(item2.getProdModel());
					Double prodPrice = null;
					if(null != item2.getProdPrice()){
						prodPrice=item2.getProdPrice().doubleValue();
					}
					lwhaff.setPrice(prodPrice);
					lwhaff.setStatus(returnItemBatchDO.getStatus());//货物等级
					lwhaff.setBillCode(curAP.getReturnsocode());
					lwhaff.setBillType("XT");//设置为销售退货编码的头字符，，供报表使用
					lwhaff.setUnit(item2.getProdUnit());
					lwhaff.setJunit(item2.getProdBUnit());
					lwhaff.setWhCode(curAP.getWhcode());
					lwhaff.setWhname(curAP.getWhname());
					lwhaff.setHubCode(item2.getHubcode());
					lwhaff.setHubName(item2.getHubname());
					
					lwhaff.setQuantity(returnItemBatchDO.getSqthQuantity());//当前单位加库库存，正数
					lwhaff.setJquantity(returnItemBatchDO.getSqthBQuantity());//基本单位加库库存，正数
					
					logicWhAffStockService.updateWhAffstockQuantity(lwhaff, user,false);
					
				}
			}
		}else{
			LogicWhAffDO lwhaff=new LogicWhAffDO();
			lwhaff.setCode(item2.getProdNo());
			lwhaff.setName(item2.getProdName());
			lwhaff.setSpec(item2.getProdSpecDesc());
			lwhaff.setBatch("NoBatch");
			lwhaff.setBrand(item2.getProdModel());
			Double prodPrice = null;
			if(null != item2.getProdPrice()){
				prodPrice=item2.getProdPrice().doubleValue();
			}
			lwhaff.setPrice(prodPrice);
			lwhaff.setStatus(item2.getStatus());//货物等级
			lwhaff.setBillCode(curAP.getReturnsocode());
			lwhaff.setBillType("XT");//设置为销售退货编码的头字符，，供报表使用
			lwhaff.setUnit(item2.getProdUnit());
			lwhaff.setJunit(item2.getProdBUnit());
			lwhaff.setWhCode(curAP.getWhcode());
			lwhaff.setWhname(curAP.getWhname());
			lwhaff.setHubCode(item2.getHubcode());
			lwhaff.setHubName(item2.getHubname());
			
			lwhaff.setQuantity(item2.getSqthQuantity());//当前单位加库库存，正数
			lwhaff.setJquantity(item2.getSqthBQuantity());//基本单位加库库存，正数
			
			logicWhAffStockService.updateWhAffstockQuantity(lwhaff, user,false);
		}
			
	}

	@Override
	public Integer deleteBizRemoved(String id) throws SyBaseException {
		// TODO Auto-generated method stub
		return null;
	}
}
